// 日期格式化
export function parseTime(time, pattern) {
    if (arguments.length === 0 || !time) {
      return null;
    }
    const format = pattern || '{y}-{m}-{d} {h}:{i}:{s}';
    let date;
    if (typeof time === 'object') {
      date = time;
    } else {
      if (typeof time === 'string' && /^[0-9]+$/.test(time)) {
        time = parseInt(time);
      } else if (typeof time === 'string') {
        time = time
          .replace(new RegExp(/-/gm), '/')
          .replace('T', ' ')
          .replace(new RegExp(/\.[\d]{3}/gm), '');
      }
      if (typeof time === 'number' && time.toString().length === 10) {
        time = time * 1000;
      }
      date = new Date(time);
    }
    const formatObj = {
      y: date.getFullYear(),
      m: date.getMonth() + 1,
      d: date.getDate(),
      h: date.getHours(),
      i: date.getMinutes(),
      s: date.getSeconds(),
      a: date.getDay()
    };
    return format.replace(/{(y|m|d|h|i|s|a)+}/g, (result, key) => {
      let value = formatObj[key];
      // Note: getDay() returns 0 on Sunday
      if (key === 'a') {
        return ['日', '一', '二', '三', '四', '五', '六'][value];
      }
      if (result.length > 0 && value < 10) {
        value = '0' + value;
      }
      return value || 0;
    });
  }
  
  /**
   * 添加日期范围
   * @param params
   * @param dateRange
   * @param propName
   */
  export const addDateRange = (params, dateRange, propName) => {
    const search = params;
    search.params = typeof search.params === 'object' && search.params !== null && !Array.isArray(search.params) ? search.params : {};
    dateRange = Array.isArray(dateRange) ? dateRange : [];
    if (typeof propName === 'undefined') {
      search.params.beginTime = dateRange[0];
      search.params.endTime = dateRange[1];
    } else {
      search.params['begin' + propName] = dateRange[0];
      search.params['end' + propName] = dateRange[1];
    }
    return search;
  };
  
  // 回显数据字典
  export const selectDictLabel = (datas, value) => {
    if (value === undefined) {
      return '';
    }
    const actions = [];
    Object.keys(datas).some((key) => {
      if (datas[key].value == '' + value) {
        actions.push(datas[key].label);
        return true;
      }
    });
    if (actions.length === 0) {
      actions.push(value);
    }
    return actions.join('');
  };
  
  // 回显数据字典（字符串数组）
  export const selectDictLabels = (datas, value, separator) => {
    if (value === undefined || value.length === 0) {
      return '';
    }
    if (Array.isArray(value)) {
      value = value.join(',');
    }
    const actions = [];
    const currentSeparator = separator === undefined ? ',' : separator;
    const temp = value.split(currentSeparator);
    temp.forEach((val) => {
      let match = false;
      Object.keys(datas).forEach((key) => {
        if (datas[key].value === '' + val) {
          actions.push(datas[key].label + currentSeparator);
          match = true;
        }
      });
      if (!match) {
        actions.push(val + currentSeparator);
      }
    });
    return actions.join('').substring(0, actions.join('').length - 1);
  };
  
  // 字符串格式化(%s )
//   export function sprintf(str) {
//     if (arguments.length !== 0) {
//       let flag = true,
//         i = 1;
//       str = str.replace(/%s/g, function () {
//         const arg = arguments[i++];
//         if (typeof arg === 'undefined') {
//           flag = false;
//           return '';
//         }
//         return arg;
//       });
//       return flag ? str : '';
//     }
//   }
  export function sprintf(str) {
    // 使用剩余参数语法来获取除第一个参数之外的所有参数
    const args = [...arguments].slice(1);
    let i = 0;
    // 使用全局替换和箭头函数确保回调中的`arguments`不会引发问题
    str = str.replace(/%s/g, () => {
        const arg = args[i++];
        return typeof arg !== 'undefined' ? arg : '';
    });
    return str;
}
  
  // 转换字符串，undefined,null等转化为""
  export const parseStrEmpty = (str) => {
    if (!str || str === 'undefined' || str === 'null') {
      return '';
    }
    return str;
  };
  
  // 数据合并
  export const mergeRecursive = (source, target) => {
    for (const p in target) {
      try {
        if (typeof target[p] === 'object' && target[p] !== null) {
          source[p] = mergeRecursive(source[p] || {}, target[p]);
        } else {
          source[p] = target[p];
        }
      } catch (e) {
        source[p] = target[p];
      }
    }
    return source;
  };
  
  /**
   * 构造树型结构数据
   * @param {*} data 数据源
   * @param {*} id id字段 默认 'id'
   * @param {*} parentId 父节点字段 默认 'parentId'
   * @param {*} children 孩子节点字段 默认 'children'
   */
  export const handleTree = (data, id = 'id', parentId = 'parentId', children = 'children') => {
    const config = {
      id: id,
      parentId: parentId,
      childrenList: children
    };
  
    const childrenListMap = {};
    const nodeIds = {};
    const tree = [];
  
    for (const d of data) {
      const parentIdValue = d[config.parentId];
      if (!childrenListMap[parentIdValue]) {
        childrenListMap[parentIdValue] = [];
      }
      nodeIds[d[config.id]] = d;
      childrenListMap[parentIdValue].push(d);
    }
  
    for (const d of data) {
      const parentIdValue = d[config.parentId];
      if (!nodeIds[parentIdValue]) {
        tree.push(d);
      }
    }
  
    const adaptToChildrenList = (o) => {
      if (childrenListMap[o[config.id]]) {
        o[config.childrenList] = childrenListMap[o[config.id]];
      }
      if (o[config.childrenList]) {
        for (const c of o[config.childrenList]) {
          adaptToChildrenList(c);
        }
      }
    };
  
    for (const t of tree) {
      adaptToChildrenList(t);
    }
  
    return tree;
  };
  
  /**
   * 参数处理
   * @param {*} params  参数
   */
  export const tansParams = (params) => {
    let result = '';
    for (const propName of Object.keys(params)) {
      let value = params[propName];
      if (typeof value === "string") {
        value = value.trim();
      }
      const part = encodeURIComponent(propName) + '=';
      if (value !== null && value !== '' && value !== undefined) {
        if (typeof value === 'object') {
          for (const key of Object.keys(value)) {
            if (value[key] !== null && value[key] !== '' && value[key] !== undefined) {
              const params = propName + '[' + key + ']';
              const subPart = encodeURIComponent(params) + '=';
              result += subPart + encodeURIComponent(value[key]) + '&';
            }
          }
        } else {
          result += part + encodeURIComponent(value) + '&';
        }
      }
    }
    // 移除最后一个多余的 '&'
    if (result.length > 0) {
      result = result.slice(0, -1);
    }
    return result;
  };
  
  // 返回项目路径
  export const getNormalPath = (p) => {
    if (p.length === 0 || !p || p === 'undefined') {
      return p;
    }
    const res = p.replace('//', '/');
    if (res[res.length - 1] === '/') {
      return res.slice(0, res.length - 1);
    }
    return res;
  };
  
  // 验证是否为blob格式
  export const blobValidate = (data) => {
    return data.type !== 'application/json';
  };
  
  export default {
    handleTree
  };
  